import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'dart:developer' as developer;

// 🔥 导入MessageChatController，用于获取聊天状态
import '../../pages/message/message_chat/controller.dart';
// 🔥 导入AppLifecycleService，用于检查前台/后台状态
import '../services/app_lifecycle_service.dart';

/// 智能通知工具类
/// 根据当前页面状态决定显示方式：聊天界面直接显示 vs 顶部弹窗通知
// 通知队列项
class NotificationQueueItem {
  final String senderUserId;
  final String senderName;
  final String senderAvatar;
  final String messageContent;
  final DateTime timestamp;
  final String? messageId; // 🔥 新增：消息ID，用于去重

  NotificationQueueItem({
    required this.senderUserId,
    required this.senderName,
    required this.senderAvatar,
    required this.messageContent,
    DateTime? timestamp,
    this.messageId, // 🔥 新增消息ID参数
  }) : timestamp = timestamp ?? DateTime.now();
}

class SmartNotificationUtil {
  static SmartNotificationUtil? _instance;
  static SmartNotificationUtil get instance => _instance ??= SmartNotificationUtil._();
  
  SmartNotificationUtil._();
  
  // Flutter本地通知插件实例
  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin = 
      FlutterLocalNotificationsPlugin();
  
  // 当前是否正在显示顶部通知
  final RxBool _isShowingTopNotification = false.obs;
  
  // 🔥 通知队列 - 跟踪排队等待显示的通知
  final List<NotificationQueueItem> _notificationQueue = [];
  
  // 🔥 正在处理通知的标记，避免重复处理
  bool _isProcessingQueue = false;
  
  // 🔥 新增：已处理的消息ID缓存，防止重复通知同一条消息
  final Set<String> _processedMessageIds = <String>{};
  
  /// 初始化通知系统
  Future<void> initialize() async {
    try {
      developer.log('🔔 =============== 初始化智能通知系统 ===============');
      
      // Android通知设置（修复LED配置错误）
      const AndroidInitializationSettings initializationSettingsAndroid =
          AndroidInitializationSettings('@mipmap/ic_launcher');
      
      // iOS通知设置
      const DarwinInitializationSettings initializationSettingsDarwin =
          DarwinInitializationSettings(
            requestAlertPermission: true,
            requestBadgePermission: true,
            requestSoundPermission: true,
          );
      
      const InitializationSettings initializationSettings =
          InitializationSettings(
            android: initializationSettingsAndroid,
            iOS: initializationSettingsDarwin,
          );
      
      await _flutterLocalNotificationsPlugin.initialize(
        initializationSettings,
        onDidReceiveNotificationResponse: _onNotificationTapped,
      );
      
      developer.log('✅ 智能通知系统初始化完成');
      
    } catch (e) {
      developer.log('💥 智能通知系统初始化失败: $e');
    }
  }
  
  /// 处理通知点击事件
  void _onNotificationTapped(NotificationResponse notificationResponse) {
    developer.log('📱 用户点击了通知: ${notificationResponse.payload}');
    // 可以在这里处理点击通知后的跳转逻辑
  }
  
  /// 智能处理消息通知
  /// [senderUserId] 发送者用户ID
  /// [senderName] 发送者昵称
  /// [senderAvatar] 发送者头像URL
  /// [messageContent] 消息内容
  /// [currentChatUserId] 当前聊天页面的用户ID（如果在聊天页面）
  /// [messageId] 消息ID，用于去重（可选）
  Future<void> handleMessageNotification({
    required String senderUserId,
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    String? currentChatUserId,
    String? messageId, // 🔥 新增消息ID参数
  }) async {
    try {
      developer.log('🔔 =============== 智能消息通知处理 ===============');
      developer.log('📨 消息发送者: $senderName (ID: $senderUserId)');
      developer.log('💬 消息内容: $messageContent');
      developer.log('🔤 消息内容长度: ${messageContent.length}');
      developer.log('📱 当前聊天对象ID: $currentChatUserId');
      developer.log('🔗 发送者头像URL: $senderAvatar');
      developer.log('🆔 消息ID: ${messageId ?? "无ID"}');
      
      // 🔥 消息去重检查
      if (messageId != null && messageId.isNotEmpty) {
        if (_processedMessageIds.contains(messageId)) {
          developer.log('✋ =============== 消息去重拦截 ===============');
          developer.log('📨 消息ID: $messageId');
          developer.log('⚠️ 该消息已经处理过，跳过重复通知');
          developer.log('📊 已处理消息数: ${_processedMessageIds.length}');
          developer.log('✅ =============== 去重检查完成 ===============');
          return;
        }
        
        // 记录该消息ID为已处理
        _processedMessageIds.add(messageId);
        developer.log('✅ 消息ID已记录为已处理: $messageId (总计: ${_processedMessageIds.length})');
        
        // 🔥 限制缓存大小，防止内存泄漏（保留最近1000条消息ID）
        if (_processedMessageIds.length > 1000) {
          final excessCount = _processedMessageIds.length - 1000;
          final oldIds = _processedMessageIds.take(excessCount).toList();
          for (final oldId in oldIds) {
            _processedMessageIds.remove(oldId);
          }
          developer.log('🗑️ 清理过旧的消息ID缓存: $excessCount个');
        }
      } else {
        developer.log('⚠️ 消息ID为空，无法进行去重检查');
      }
      
      // 🔥 新增：检查App前台/后台状态
      final appLifecycleService = Get.find<AppLifecycleService>();
      final shouldShowSystemNotification = appLifecycleService.shouldShowSystemNotification();
      
      if (shouldShowSystemNotification) {
        developer.log('📱 App在后台，智能通知系统跳过（后台由极光推送处理）');
        return;
      }
      
      developer.log('📱 App在前台，智能通知系统继续处理');
      
      // 获取当前路由信息
      final currentRoute = Get.currentRoute;
      developer.log('🌍 当前路由: $currentRoute');
      
      // 🔥 详细的路由和聊天状态检查
      developer.log('🔍 =============== 聊天状态详细检查 ===============');
      
      // 检查是否在聊天页面且是同一个用户
      final isInChatWithSameUser = _isInChatPageWithUser(currentRoute, currentChatUserId, senderUserId);
      developer.log('👥 是否在与同一用户聊天: $isInChatWithSameUser');
      
      if (isInChatWithSameUser) {
        developer.log('✅ 当前正在与发送者聊天，消息将直接显示在聊天界面');
        // 🔥 清除该用户的所有排队通知，因为用户已经在聊天界面
        _clearUserNotificationsFromQueue(senderUserId);
        return;
      }
      
      // 🔥 检查当前是否已有通知在显示
      developer.log('📱 当前通知显示状态: ${_isShowingTopNotification.value}');
      
      // 🔥 添加通知到队列而不是直接显示
      developer.log('🔔 添加通知到队列');
      developer.log('📊 当前队列长度: ${_notificationQueue.length}');
      
      _addNotificationToQueue(
        senderUserId: senderUserId,
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageContent: messageContent,
        messageId: messageId, // 🔥 传递消息ID
      );
      
      developer.log('📊 添加后队列长度: ${_notificationQueue.length}');
      developer.log('🔄 是否正在处理队列: $_isProcessingQueue');
      
      // 🔥 处理通知队列
      _processNotificationQueue();
      
    } catch (e) {
      developer.log('💥 智能消息通知处理异常: $e');
    }
  }
  
  /// 检查是否在聊天页面且是同一个用户
  bool _isInChatPageWithUser(String currentRoute, String? currentChatUserId, String senderUserId) {
    // 检查是否在聊天页面
    final isInChatPage = currentRoute.contains('message_chat') || 
                        currentRoute.contains('MessageChat');
    
    if (!isInChatPage) {
      developer.log('📱 不在聊天页面，需要显示通知');
      return false;
    }
    
    developer.log('📱 正在聊天页面，检查是否与发送者聊天...');
    
    // 🔥 修复：如果currentChatUserId为空，尝试从控制器中获取
    String? finalChatUserId = currentChatUserId;
    
    if (finalChatUserId == null) {
      developer.log('📱 当前聊天用户ID为空，尝试从MessageChatController获取...');
      
      try {
        // 🔥 尝试通过不同的controllerTag查找MessageChatController
        // 因为controllerTag是基于聊天对象的ID，我们需要尝试所有可能的组合
        final possibleTags = [
          "message_chat_$senderUserId",  // 如果正在与发送者聊天
        ];
        
        MessageChatController? foundController;
        String? foundTag;
        
        for (final tag in possibleTags) {
          try {
            foundController = Get.find<MessageChatController>(tag: tag);
            foundTag = tag;
            break;
          } catch (e) {
            continue;
          }
        }
        
        if (foundController != null) {
          finalChatUserId = foundController.chatUser?.id;
          if (finalChatUserId != null) {
            developer.log('📱 从控制器($foundTag)获取到聊天用户ID: $finalChatUserId');
          } else {
            developer.log('📱 控制器($foundTag)中的聊天用户ID也为空');
          }
        } else {
          developer.log('📱 未找到任何MessageChatController实例');
        }
        
        // 🔥 如果仍未获取到，尝试从Get.arguments中获取
        if (finalChatUserId == null) {
          try {
            final args = Get.arguments;
            if (args is Map<String, dynamic> && args['userId'] != null) {
              finalChatUserId = args['userId']?.toString();
              developer.log('📱 从路由参数获取到用户ID: $finalChatUserId');
            }
          } catch (e2) {
            developer.log('📱 从路由参数获取用户ID也失败: $e2');
          }
        }
        
      } catch (e) {
        developer.log('📱 获取聊天用户ID过程异常: $e');
      }
    }
    
    // 最终判断
    if (finalChatUserId == null) {
      developer.log('📱 无法确定当前聊天用户ID，默认显示通知');
      return false;
    }
    
    if (finalChatUserId != senderUserId) {
      developer.log('📱 正在与其他用户聊天 (当前: $finalChatUserId, 发送者: $senderUserId)，需要显示通知');
      return false;
    }
    
    developer.log('📱 正在与发送者聊天，消息直接显示');
    return true;
  }
  
  /// 显示顶部弹窗通知
  Future<void> _showTopBannerNotification({
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    required String senderUserId,
  }) async {
    developer.log('🎭 =============== 显示顶部弹窗通知 ===============');
    developer.log('👤 发送者: $senderName');
    developer.log('🆔 用户ID: $senderUserId');
    developer.log('💬 消息内容: $messageContent');
    developer.log('🖼️ 头像URL: $senderAvatar');
    developer.log('📱 当前通知显示状态: ${_isShowingTopNotification.value}');
    
    // 如果已经在显示通知，先关闭之前的
    if (_isShowingTopNotification.value) {
      developer.log('⚠️ 已有通知在显示，先关闭之前的通知');
      Get.back();
      await Future.delayed(const Duration(milliseconds: 100));
    }
    
    _isShowingTopNotification.value = true;
    developer.log('✅ 设置通知显示状态为true');
    
    developer.log('🎨 开始构建GetX Snackbar...');
    
    // 显示顶部弹窗
    Get.snackbar(
      '', // 空标题，使用自定义内容
      '',
      snackPosition: SnackPosition.TOP,
      backgroundColor: Colors.white,
      duration: const Duration(milliseconds: 2500), // 2.5秒自动消失
      margin: const EdgeInsets.fromLTRB(8, 25, 8, 0), // 🔥 减少顶部边距到25px，更接近状态栏
      borderRadius: 12, // 🔥 减少圆角，更紧凑
      boxShadows: [
        BoxShadow(
          color: Colors.black.withOpacity(0.12), // 稍微减少阴影强度
          blurRadius: 8, // 减少模糊半径
          offset: const Offset(0, 2), // 减少阴影偏移
        ),
      ],
      titleText: const SizedBox.shrink(), // 隐藏默认标题
      messageText: _buildNotificationContent(
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageContent: messageContent,
      ),
      onTap: (_) {
        // 点击通知跳转到聊天页面
        _navigateToChat(senderUserId, senderName, senderAvatar);
      },
      isDismissible: true, // 🔥 支持滑动关闭
      dismissDirection: DismissDirection.horizontal, // 🔥 水平滑动关闭
      forwardAnimationCurve: Curves.easeOutBack,
      reverseAnimationCurve: Curves.easeInBack,
      animationDuration: const Duration(milliseconds: 400), // 🔥 动画时长
    );
    
    developer.log('📢 GetX Snackbar已调用显示');
    
    // 震动反馈
    try {
      HapticFeedback.lightImpact();
      developer.log('📳 震动反馈已触发');
    } catch (e) {
      developer.log('💥 震动反馈异常: $e');
    }
    
    developer.log('⏰ 设置2.5秒后自动标记为不显示状态');
    
    // 2.5秒后自动标记为不显示状态
    Future.delayed(const Duration(milliseconds: 2500), () {
      _isShowingTopNotification.value = false;
      developer.log('⏰ 2.5秒已过，通知显示状态已重置为false');
    });
    
    developer.log('🎉 =============== 顶部弹窗通知设置完成 ===============');
  }
  
  /// 构建通知内容
  Widget _buildNotificationContent({
    required String senderName,
    required String senderAvatar,
    required String messageContent,
  }) {
    developer.log('🖼️ 构建通知内容 - 头像URL: $senderAvatar');
    
    return Container(
      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10), // 🔥 减少内边距，更紧凑
      child: Row(
        children: [
          // 发送者头像 - 缩小尺寸
          Container(
            width: 40, // 🔥 从48减少到40
            height: 40, // 🔥 从48减少到40
            decoration: BoxDecoration(
              shape: BoxShape.circle,
              color: Colors.grey[300],
              // 修复头像显示问题 - 使用DecorationImage确保正确显示
              image: (senderAvatar.isNotEmpty) 
                  ? DecorationImage(
                      image: NetworkImage(senderAvatar),
                      fit: BoxFit.cover,
                      onError: (exception, stackTrace) {
                        developer.log('❌ 头像加载失败: $exception');
                      },
                    )
                  : null,
            ),
            child: (senderAvatar.isEmpty) 
                ? const Icon(Icons.person, color: Colors.grey, size: 20) // 🔥 图标也缩小
                : null,
          ),
          
          const SizedBox(width: 10), // 🔥 减少间距从14到10
          
          // 消息内容
          Expanded(
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              mainAxisSize: MainAxisSize.min,
              children: [
                // 发送者昵称
                Text(
                  senderName,
                  style: const TextStyle(
                    fontSize: 14, // 🔥 从16减少到14
                    fontWeight: FontWeight.w600,
                    color: Colors.black87,
                  ),
                  maxLines: 1,
                  overflow: TextOverflow.ellipsis,
                ),
                
                const SizedBox(height: 3), // 🔥 减少间距从6到3
                
                // 消息内容
                Text(
                  messageContent,
                  style: const TextStyle(
                    fontSize: 13, // 🔥 从14减少到13
                    color: Colors.black54,
                    height: 1.2, // 🔥 减少行高从1.3到1.2
                  ),
                  maxLines: 1, // 🔥 从2行减少到1行，更紧凑
                  overflow: TextOverflow.ellipsis,
                ),
              ],
            ),
          ),
          
          // 保持右边距
          const SizedBox(width: 8), // 🔥 减少右边距从12到8
        ],
      ),
    );
  }
  
  /// 导航到聊天页面或好友申请页面 - 🚫 已禁用所有跳转功能
  void _navigateToChat(String userId, String userName, String userAvatar) {
    try {
      // 关闭当前通知
      Get.back();
      _isShowingTopNotification.value = false;
      
      // 🔥 清除该用户的所有排队通知
      _clearUserNotificationsFromQueue(userId);
      
      // 🚫 用户要求禁用所有内部通知跳转功能
      developer.log('🚫 =============== 通知跳转已禁用 ===============');
      developer.log('👤 用户点击了通知: $userName (ID: $userId)');
      developer.log('❌ 根据用户要求，已禁用所有内部通知跳转功能');
      developer.log('🚫 原本要跳转的页面已被阻止');
      developer.log('✅ 通知已关闭，但不执行任何跳转操作');
      developer.log('🚫 =======================================');
      
      // 🚫 以下所有跳转代码已被禁用
      /*
      // 🔥 特殊处理：好友申请通知跳转到好友申请页面
      if (userId == 'friend_request') {
        developer.log('🤝 点击好友申请通知，跳转到聊天页面并打开好友申请弹出框');
        Get.toNamed('/message_message_index', arguments: {'auto_show_friend_requests': true});
        return;
      }
      
      // 🔥 特殊处理：活动申请通知跳转到活动申请用户管理页面
      if (userId == 'activity_request') {
        developer.log('🎯 点击活动申请通知，跳转到活动申请用户管理页面');
        Get.toNamed('/activity_application_management');
        return;
      }
      
      // 普通聊天消息：跳转到聊天页面
      developer.log('🚀 点击通知跳转到聊天页面: $userName');
      Get.toNamed(
        '/message_message_chat',
        arguments: {
          'userId': userId,
          'userName': userName,
          'userAvatar': userAvatar,
        },
      );
      */
      
    } catch (e) {
      developer.log('💥 处理通知点击异常: $e');
    }
  }
  
  /// 🔥 添加通知到队列
  void _addNotificationToQueue({
    required String senderUserId,
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    String? messageId, // 🔥 新增messageId参数
  }) {
    final notificationItem = NotificationQueueItem(
      senderUserId: senderUserId,
      senderName: senderName,
      senderAvatar: senderAvatar,
      messageContent: messageContent,
      messageId: messageId, // 🔥 传递消息ID
    );
    
    _notificationQueue.add(notificationItem);
    developer.log('📤 通知已添加到队列: ${senderName} - $messageContent (队列长度: ${_notificationQueue.length}) [消息ID: ${messageId ?? "无"}]');
  }
  
  /// 🔥 处理通知队列 - 显示下一个通知
  Future<void> _processNotificationQueue() async {
    developer.log('🔄 =============== 开始处理通知队列 ===============');
    developer.log('📊 队列当前状态: 长度=${_notificationQueue.length}, 正在处理=$_isProcessingQueue, 正在显示=${_isShowingTopNotification.value}');
    
    // 如果已经在处理队列或正在显示通知，则等待
    if (_isProcessingQueue || _isShowingTopNotification.value) {
      developer.log('⏱️ 队列正在处理中或正在显示通知，跳过处理');
      return;
    }
    
    // 如果队列为空，无需处理
    if (_notificationQueue.isEmpty) {
      developer.log('📭 通知队列为空，无需处理');
      return;
    }
    
    _isProcessingQueue = true;
    
    try {
      // 获取队列中的第一个通知
      final notification = _notificationQueue.removeAt(0);
      developer.log('📢 =============== 处理队列通知 ===============');
      developer.log('👤 发送者: ${notification.senderName}');
      developer.log('🆔 用户ID: ${notification.senderUserId}');
      developer.log('💬 消息内容: ${notification.messageContent}');
      developer.log('🖼️ 头像URL: ${notification.senderAvatar}');
      
      // 再次检查用户是否已经在聊天页面（避免竞态条件）
      final currentRoute = Get.currentRoute;
      developer.log('🌍 当前路由: $currentRoute');
      
      final isInChatWithSameUser = _isInChatPageWithUser(currentRoute, null, notification.senderUserId);
      developer.log('👥 是否在与同一用户聊天: $isInChatWithSameUser');
      
      if (isInChatWithSameUser) {
        developer.log('❌ 用户已在聊天页面，跳过显示通知: ${notification.senderName}');
        // 清除该用户剩余的通知并继续处理队列
        _clearUserNotificationsFromQueue(notification.senderUserId);
      } else {
        developer.log('✅ 准备显示顶部通知: ${notification.senderName}');
        
        // 显示通知
        await _showTopBannerNotification(
          senderName: notification.senderName,
          senderAvatar: notification.senderAvatar,
          messageContent: notification.messageContent,
          senderUserId: notification.senderUserId,
        );
        
        developer.log('⏰ 等待通知显示完成...');
        
        // 等待通知显示完成后再处理下一个
        await Future.delayed(const Duration(milliseconds: 2600)); // 稍微超过通知显示时间
        
        developer.log('✅ 通知显示完成');
      }
      
      // 递归处理下一个通知
      if (_notificationQueue.isNotEmpty) {
        developer.log('🔄 继续处理下一个通知 (剩余: ${_notificationQueue.length})');
        Future.microtask(() => _processNotificationQueue());
      } else {
        developer.log('🎉 所有通知处理完成');
      }
      
    } catch (e) {
      developer.log('💥 处理通知队列异常: $e');
    } finally {
      _isProcessingQueue = false;
      developer.log('🏁 =============== 通知队列处理结束 ===============');
    }
  }
  
  /// 🔥 清除特定用户的排队通知
  void _clearUserNotificationsFromQueue(String userId) {
    final beforeCount = _notificationQueue.length;
    _notificationQueue.removeWhere((notification) => notification.senderUserId == userId);
    final afterCount = _notificationQueue.length;
    final removedCount = beforeCount - afterCount;
    
    if (removedCount > 0) {
      developer.log('🗑️ 已清除用户 $userId 的 $removedCount 条排队通知 (剩余队列: $afterCount)');
    } else {
      developer.log('🔍 用户 $userId 无排队通知需要清除');
    }
  }
  
  /// 🔥 公共方法：清除特定用户的所有通知（包括正在显示的）
  Future<void> clearUserNotifications(String userId) async {
    try {
      developer.log('🧹 =============== 清除用户通知 ===============');
      developer.log('👤 目标用户ID: $userId');
      
      // 清除队列中的通知
      _clearUserNotificationsFromQueue(userId);
      
      // 如果当前正在显示该用户的通知，也关闭
      if (_isShowingTopNotification.value) {
        // 这里需要检查当前显示的通知是否是该用户的
        // 由于无法直接获取当前显示通知的用户ID，我们采用保守策略：关闭当前通知
        Get.back();
        _isShowingTopNotification.value = false;
        developer.log('❌ 已关闭当前显示的通知');
      }
      
      developer.log('✅ 用户通知清除完成');
      
    } catch (e) {
      developer.log('💥 清除用户通知异常: $e');
    }
  }
  
  /// 清除所有通知
  Future<void> clearAllNotifications() async {
    try {
      await _flutterLocalNotificationsPlugin.cancelAll();
      _isShowingTopNotification.value = false;
    } catch (e) {
      developer.log('💥 清除通知失败: $e');
    }
  }
}
